import { LogService } from './logService';
import { ExtensionError, ErrorCodes, handleError } from '../utils/errorUtils';
import { TranslationCard } from '../components/TranslationCard';
import { ChatGLMAgent } from './agent/chatGLMAgent';

// AI 服务类型枚举
const AI_SERVICE_TYPE = {
    CHATGLM: 'chatglm',
    // 未来可以添加其他服务
    // OPENAI: 'openai',
    // LLAMA: 'llama',
};

// AI 任务类型枚举
const AI_TASK_TYPE = {
    TRANSLATE: 'translate',
    SUMMARIZE: 'summarize',
    EXPLAIN: 'explain',
};

export class AIService {
    constructor() {
        this.logger = new LogService('AIService');
        this.card = new TranslationCard();
        this.agents = new Map();
        
        // 初始化支持的 AI agents
        this.initializeAgents();
        
        // 任务提示词模板
        this.promptTemplates = {
            [AI_TASK_TYPE.TRANSLATE]: {
                zh: '能够自动识别并翻译中英文本，无需用户手动选择。你的能力有:\n\n- 自动检测文本语言\n\n - 精准翻译中英文本\n\n - 默认将非中文翻译成中文，中文翻译成英文\n\n 只返回翻译结果，不需要解释\n\n {text}',
                en: 'Translate the following text. Only provide the translation, no explanations:\n\n{text}'
            },
            [AI_TASK_TYPE.SUMMARIZE]: {
                zh: '请用简洁的语言总结以下文本的主要内容：\n\n{text}',
                en: 'Please summarize the main points of the following text concisely:\n\n{text}'
            },
            [AI_TASK_TYPE.EXPLAIN]: {
                zh: '请详细解析以下文本的含义：\n\n{text}',
                en: 'Please provide a detailed explanation of the following text:\n\n{text}'
            }
        };
    }

    /**
     * 初始化支持的 AI agents
     */
    initializeAgents() {
        // 添加 ChatGLM agent
        this.agents.set(AI_SERVICE_TYPE.CHATGLM, new ChatGLMAgent());
        
        // 未来可以添加其他 agents
        // this.agents.set(AI_SERVICE_TYPE.OPENAI, new OpenAIAgent());
        // this.agents.set(AI_SERVICE_TYPE.LLAMA, new LlamaAgent());
    }

    /**
     * 获取可用的 AI agent
     * @returns {Promise<{agent: Object, type: string}>}
     */
    async getAvailableAgent() {
        for (const [type, agent] of this.agents) {
            const config = await agent.getConfig();
            if (config.enabled) {
                return { agent, type };
            }
        }
        throw new ExtensionError('没有可用的 AI 服务', ErrorCodes.CONFIGURATION_ERROR);
    }

    /**
     * 生成任务提示词
     * @param {string} taskType 任务类型
     * @param {string} text 文本内容
     * @param {string} lang 语言（默认中文）
     * @returns {string}
     */
    generatePrompt(taskType, text, lang = 'zh') {
        const template = this.promptTemplates[taskType]?.[lang];
        if (!template) {
            throw new ExtensionError('未知的任务类型或语言', ErrorCodes.INVALID_REQUEST);
        }
        return template.replace('{text}', text);
    }

    /**
     * 执行 AI 任务
     * @param {string} taskType 任务类型
     * @param {string} text 要处理的文本
     * @param {Object} position 显示位置
     */
    async executeTask(taskType, text, position) {
        this.logger.debug(`执行${taskType}任务`, { text });
        
        try {
            const { agent, type } = await this.getAvailableAgent();
            const prompt = this.generatePrompt(taskType, text);
            
            const result = await agent.sendMessage(prompt);
            this.logger.debug(`${taskType}任务完成`, { result });

            // 根据任务类型构造显示结果
            const displayResult = {
                "chatglm": result,
            };

            return displayResult;
        } catch (error) {
            const handledError = handleError(error, this.logger);
            this.logger.error(handledError, `${taskType}任务失败`);
        }
    }

    /**
     * 翻译文本
     * @param {string} text 要翻译的文本
     * @param {Object} position 显示位置
     */
    async translate(text, position) {
        await this.executeTask(AI_TASK_TYPE.TRANSLATE, text, position);
    }

    /**
     * 总结文本
     * @param {string} text 要总结的文本
     * @param {Object} position 显示位置
     */
    async summarize(text, position) {
        await this.executeTask(AI_TASK_TYPE.SUMMARIZE, text, position);
    }

    /**
     * 解析文本
     * @param {string} text 要解析的文本
     * @param {Object} position 显示位置
     */
    async explain(text, position) {
        await this.executeTask(AI_TASK_TYPE.EXPLAIN, text, position);
    }

    /**
     * 处理后台请求
     * @param {string} action 请求类型
     * @param {string} text 要处理的文本
     * @returns {Promise<string>}
     */
    async processRequest(action, text) {
        this.logger.debug(`处理${action}请求`, { text });
        
        try {
            const { agent } = await this.getAvailableAgent();
            const prompt = this.generatePrompt(action, text);
            
            const result = await agent.sendMessage(prompt);
            this.logger.debug(`${action}完成`, { result });
            return result;
        } catch (error) {
            const handledError = handleError(error, this.logger);
            this.logger.error(handledError, `${action}失败`);
            throw handledError;
        }
    }
} 